//Include("Mz");
//Include("Mz.extend");
//Include("Mz.BaseClass");
//Include("Mz.BaseEvent");


/**
 * @fileoverview Mz.TimeLine
 * 创建一条时间线，可以依托于这条时间线脉冲控制效果中的渐进过程
 * @author meizz
 * @version 20090223
 */



/**
 * 时间线类共对外暴露，对于这些暴露出来的属性/接口/事件全部在类的初始化时 
 * new Mz.TimeLine({json})通过这个JSON往类里传递：
 * 5个属性：
 *  <li>interval  {Int} 时间脉冲的间隔时间[读写]</li>
 *  <li>duration  {Int} 该条时间线的总时长[读写]</li>
 *  <li>continual {Boolean} 时间脉冲的间隔时间[读写]</li>
 *  <li>trend     {Int} 效果渐强/渐弱变化的标识[读写]</li>
 *  <li>schedule  {Int} 当前时间线的进度[只读]</li>
 * 
 * 4个接口(你可以实现这些接口，在类初始化时的JSON参数里传入一个同名的函数即可)
 *  <li>initialize()  在时间线运行之前做初始化工作</li>
 *  <li>render(schedule)  在每个时间脉冲中所进行的操作</li>
 *  <li>finish()      在时间线结束之后该做的工作</li>
 *  <li>restore()     在撤销时间线后所做的恢复操作</li>
 * 
 * 2个方法
 * <li>cancel()</li>
 * <li>end()</li>
 * 
 * 4个事件
 *  <li>onbeforestart</li>
 *  <li>onbeforeupdate</li>
 *  <li>onafterupdate</li>
 *  <li>onafterfinish</li>
 *
 * @name Mz.TimeLine
 * @constructor
 * @param {Object} options 时间线的配置参数
 * @config {Number} [interval] 时间脉冲的间隔时间
 * @config {Number} [duration] 该条时间线的总时长
 * @config {Boolean} [continual] 时间线是否连续地对外提供脉冲
 * @config {Boolean} [trend] 效果渐强/渐弱变化的标识
 */
Mz.TimeLine = function(options){
    /** @ignore 从基类Mz.BaseClass继承构造器 */
    Mz.BaseClass.call(this);

    var me = this;

    me.interval = 15;   //milliseconds
    me.duration = 800;  //milliseconds
    me.continual= true;
    me.trend  = true;

    Mz.extend(this, options);

    me._beginTime = new Date().getTime();
    me._endTime = me._beginTime + me.duration;

    /**
     * initialize()接口，当时间线初始化同步进行的操作
     */
    if(typeof me.initialize=="function") me.initialize();
    me.dispatchEvent(new Mz.BaseEvent("onbeforestart"));
    if(me.continual) me._launch();
};
Mz.TimeLine.inherits(Mz.BaseClass, "Mz.TimeLine");

/** @ignore 每个时间脉冲所执行的程序 */
Mz.TimeLine.prototype._launch = function(){
    var me = this;
    var now = new Date().getTime();

    if(now >= me._endTime){
        me.schedule = me.trend ? 1 : 0;
        //me.schedule = me.transtion(me.schedule);
        if(typeof me.render=="function") me.render(me.schedule);

        /**
         * finish()接口，时间线结束时对应的操作
         */
        if(typeof me.finish=="function") me.finish();

        me.dispatchEvent(new Mz.BaseEvent("onafterfinish"));
        me.dispose();
        return;
    }

    /**
     * 当前时间线的进度
     * @type {Number}
     */
    if(me.trend){
        me.schedule = Math.sqrt((now-me._beginTime)/me.duration);
    } else{
        me.schedule = Math.pow((me._endTime-now)/me.duration, 2);
    }

    me.dispatchEvent(new Mz.BaseEvent("onbeforeupdate"));
    /**
     * render()接口，用来实现每个脉冲所要实现的效果
     * @param {Number} schedule 时间线的进度
     */
    if(typeof me.render=="function")me.render(me.schedule);
    me.dispatchEvent(new Mz.BaseEvent("onafterupdate"));

    if(!me.terminative){
        me._timer = setTimeout(function(){me._launch()}, me.interval);
    }
};

/**
 * 撤销当前时间线的操作，并引发 restore() 接口函数的操作
 */
Mz.TimeLine.prototype.cancel = function(){
    if(this._timer) clearTimeout(this._timer);
    this._endTime = this._beginTime;

    /**
     * restore()接口，当时间线被撤销时的恢复操作
     */
    if(typeof this.restore=="function") this.restore();
    this.dispose();
};

/**
 * 直接当前的时间线运行到结束点
 */
Mz.TimeLine.prototype.end = function(){
    if(this._timer) clearTimeout(this._timer);
    this._endTime = this._beginTime;
    this._launch();
};
